/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: sw=2 ts=8 et :
 */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

include LayersSurfaces;
include LayersMessages;
include protocol PCompositable;
include protocol PCompositorBridge;
include protocol PLayer;
include protocol PRenderFrame;
include protocol PTexture;

include "mozilla/GfxMessageUtils.h";

using struct mozilla::layers::TextureInfo from "mozilla/layers/CompositorTypes.h";
using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
using class mozilla::layers::APZTestData from "mozilla/layers/APZTestData.h";
using mozilla::layers::FrameMetrics::ViewID from "FrameMetrics.h";
using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h";
using mozilla::layers::LayersBackend from "mozilla/layers/LayersTypes.h";

/**
 * The layers protocol is spoken between thread contexts that manage
 * layer (sub)trees.  The protocol comprises atomically publishing
 * layer subtrees to a "shadow" thread context (which grafts the
 * subtree into its own tree), and atomically updating a published
 * subtree.  ("Atomic" in this sense is wrt painting.)
 */

namespace mozilla {
namespace layers {

union MaybeTransform {
  Matrix4x4;
  void_t;
};

sync protocol PLayerTransaction {
  manager PCompositorBridge;
  manages PLayer;
  manages PCompositable;

parent:
  async PLayer();
  async PCompositable(TextureInfo aTextureInfo);

  // The isFirstPaint flag can be used to indicate that this is the first update
  // for a particular document.
  sync Update(Edit[] cset, OpDestroy[] toDestroy,
              uint64_t fwdTransactionId,
              uint64_t id, TargetConfig targetConfig,
              PluginWindowData[] plugins, bool isFirstPaint,
              bool scheduleComposite, uint32_t paintSequenceNumber,
              bool isRepeatTransaction, TimeStamp transactionStart,
              int32_t paintSyncId)
    returns (EditReply[] reply);

  async PaintTime(uint64_t id, TimeDuration paintTime);

  // We don't need to send a sync transaction if
  // no transaction operate require a swap.
  async UpdateNoSwap(Edit[] cset, OpDestroy[] toDestroy,
                     uint64_t fwdTransactionId,
                     uint64_t id, TargetConfig targetConfig,
                     PluginWindowData[] plugins, bool isFirstPaint,
                     bool scheduleComposite, uint32_t paintSequenceNumber,
                     bool isRepeatTransaction, TimeStamp transactionStart,
                     int32_t paintSyncId);

  async SetLayerObserverEpoch(uint64_t layerObserverEpoch);

  // Testing APIs

  // Enter test mode, set the sample time to sampleTime, and resample
  // animations. sampleTime must not be null.
  sync SetTestSampleTime(TimeStamp sampleTime);
  // Leave test mode and resume normal compositing
  sync LeaveTestMode();

  // Returns the value of the opacity applied to the layer by animation.
  // |hasAnimationOpacity| is true if the layer has an opacity value
  // specified by animation. If it's false, |opacity| value is indefinite.
  sync GetAnimationOpacity(PLayer layer) returns (float opacity,
                                                  bool hasAnimationOpacity);

  // Returns the value of the transform applied to the layer by animation after
  // factoring out translation components introduced to account for the offset
  // of the corresponding frame and transform origin and after converting to CSS
  // pixels. If the layer is not transformed by animation, the return value will
  // be void_t.
  sync GetAnimationTransform(PLayer layer) returns (MaybeTransform transform);

  // The next time the layer tree is composited, add this async scroll offset in
  // CSS pixels for the given ViewID.
  // Useful for testing rendering of async scrolling.
  sync SetAsyncScrollOffset(ViewID id, float x, float y);

  // The next time the layer tree is composited, include this async zoom in
  // for the given ViewID.
  // Useful for testing rendering of async zooming.
  sync SetAsyncZoom(ViewID id, float zoom);

  // Flush any pending APZ repaints to the main thread.
  async FlushApzRepaints();

  // Drop any front buffers that might be retained on the compositor
  // side.
  async ClearCachedResources();

  // Schedule a composite if one isn't already scheduled.
  async ForceComposite();

  // Get a copy of the compositor-side APZ test data instance for this
  // layers id.
  sync GetAPZTestData() returns (APZTestData data);

  // Query a named property from the last frame
  sync RequestProperty(nsString property) returns (float value);

  // Tell the compositor to notify APZ that a layer has been confirmed for an
  // input event.
  async SetConfirmedTargetAPZC(uint64_t aInputBlockId, ScrollableLayerGuid[] aTargets);

  async Shutdown();
child:
  async __delete__();
};

} // namespace layers
} // namespace mozilla
